// 玩家飞机类（增强反馈版）
import { TimeManager } from './TimeManager.js';

export class Player {
    constructor(x, y) {
        this.x = x;
        this.y = y;
        this.width = 40;
        this.height = 40;
        this.speed = 5;
        
        // 碰撞盒设置（提供更好的容错）
        this.collisionBox = {
            width: 24,      // 碰撞宽度缩小到原噧40*0.6=24像素
            height: 24,     // 碰撞高度缩小到原噧40*0.6=24像素
            offsetX: 8,     // X方向中心对齐偏移 (40-24)/2=8
            offsetY: 8      // Y方向中心对齐偏移 (40-24)/2=8
        };
        
        // 受击反馈特效（使用毫秒）
        this.hitFlashTime = 0;      // 闪烁时间（毫秒）
        this.hitShakeX = 0;         // 震动X偏移
        this.hitShakeY = 0;         // 震动Y偏移
        this.hitShieldTime = 0;     // 受击护盾波纹时间（毫秒）
        this.shieldWave = 0;        // 护盾波纹
        this.invulnerable = false;  // 无敌状态
        this.invulnerableTime = 0;  // 无敌时间（毫秒）
        
        // 引擎特效
        this.enginePulse = 0;
        
        // 3D倾斜效果
        this.tiltAngle = 0;         // 当前倾斜角度
        this.targetTiltAngle = 0;   // 目标倾斜角度
        this.horizontalVelocity = 0; // 水平方向速度
        
        // 道具状态（使用毫秒）
        this.multishotActive = false;   // 多发装置激活状态
        this.multishotTime = 0;         // 多发装置剩余时间（毫秒）
        this.shieldActive = false;      // 保护罩激活状态
        this.shieldActiveTime = 0;      // 保护罩剩余时间（毫秒）
        this.shieldPhase = 0;           // 保护罩独立相位变量
        this.shieldCharges = 0;         // 保护罩充能次数（新增：一次性保护）
    }
    
    update(keys, canvas, deltaTime) {
        // 更新特效计时器
        this.updateEffects(deltaTime);
        
        // 记录之前的位置用于计算速度
        const prevX = this.x;
        
        // 移动控制
        if (keys['a'] || keys['arrowleft']) {
            this.x -= this.speed;
        }
        if (keys['d'] || keys['arrowright']) {
            this.x += this.speed;
        }
        if (keys['w'] || keys['arrowup']) {
            this.y -= this.speed;
        }
        if (keys['s'] || keys['arrowdown']) {
            this.y += this.speed;
        }
        
        // 计算水平移动速度并更新倾斜效果
        this.horizontalVelocity = this.x - prevX;
        this.updateTiltEffect(deltaTime);
        
        // 边界检测
        this.x = Math.max(0, Math.min(canvas.width - this.width, this.x));
        this.y = Math.max(0, Math.min(canvas.height - this.height, this.y));
        
        // 更新引擎脉冲
        this.enginePulse = TimeManager.updatePhase(this.enginePulse, deltaTime, TimeManager.CONSTANTS.ENGINE_PULSE_SPEED);
    }
    
    // 更新3D倾斜效果
    updateTiltEffect(deltaTime) {
        // 根据水平移动速度设置目标倾斜角度
        if (this.horizontalVelocity > 0) {
            this.targetTiltAngle = Math.PI / 12; // 向右倾斜15度
        } else if (this.horizontalVelocity < 0) {
            this.targetTiltAngle = -Math.PI / 12; // 向左倾斜15度
        } else {
            this.targetTiltAngle = 0; // 回正
        }
        
        // 平滑过渡到目标角度
        const tiltSpeed = 0.15 * (deltaTime / 16.67); // 调整为基于时间的倾斜速度
        this.tiltAngle += (this.targetTiltAngle - this.tiltAngle) * tiltSpeed;
        
        // 防止角度过小的抖动
        if (Math.abs(this.tiltAngle) < 0.01) {
            this.tiltAngle = 0;
        }
    }
    
    updateEffects(deltaTime) {
        // 更新闪烁效果
        this.hitFlashTime = TimeManager.updateTimer(this.hitFlashTime, deltaTime);
        
        // 更新震动效果
        if (this.hitShakeX !== 0) {
            this.hitShakeX *= Math.pow(0.8, deltaTime / 16.67); // 调整为基于时间的衰减
            if (Math.abs(this.hitShakeX) < 0.1) this.hitShakeX = 0;
        }
        if (this.hitShakeY !== 0) {
            this.hitShakeY *= Math.pow(0.8, deltaTime / 16.67); // 调整为基于时间的衰减
            if (Math.abs(this.hitShakeY) < 0.1) this.hitShakeY = 0;
        }
        
        // 更新受击护盾波纹效果
        if (this.hitShieldTime > 0) {
            this.hitShieldTime = TimeManager.updateTimer(this.hitShieldTime, deltaTime);
            this.shieldWave += (deltaTime / 1000) * 12; // 每秒12单位的波纹速度
        }
        
        // 更新无敌状态
        if (this.invulnerableTime > 0) {
            this.invulnerableTime = TimeManager.updateTimer(this.invulnerableTime, deltaTime);
            if (TimeManager.isTimeUp(this.invulnerableTime)) {
                this.invulnerable = false;
            }
        }
        
        // 更新道具状态
        if (this.multishotTime > 0) {
            this.multishotTime = TimeManager.updateTimer(this.multishotTime, deltaTime);
            if (TimeManager.isTimeUp(this.multishotTime)) {
                this.multishotActive = false;
            }
        }
        
        // 更新道具保护罩状态（只更新视觉效果）
        if (this.shieldActive) {
            this.shieldPhase = TimeManager.updatePhase(this.shieldPhase, deltaTime, TimeManager.CONSTANTS.SHIELD_PHASE_SPEED);
        }
    }
    
    // 受击时调用
    onHit() {
        if (this.invulnerable) return false; // 无敌状态不受伤
        
        // 检查保护罩充能
        if (this.shieldCharges > 0) {
            // 消耗保护罩充能
            this.shieldCharges--;
            
            // 触发保护罩被击破特效
            this.hitFlashTime = TimeManager.CONSTANTS.PLAYER_HIT_FLASH_TIME * 0.5; // 更短的闪烁
            this.hitShakeX = (Math.random() - 0.5) * 8; // 更轻的震动
            this.hitShakeY = (Math.random() - 0.5) * 8;
            this.hitShieldTime = TimeManager.CONSTANTS.PLAYER_SHIELD_WAVE_TIME * 1.5; // 更强的波纹效果
            this.shieldWave = 0;
            
            // 如果保护罩耗尽，关闭保护罩效果
            if (this.shieldCharges <= 0) {
                this.shieldActive = false;
                this.shieldPhase = 0;
            }
            
            return false; // 保护罩抵挡伤害，不减血
        }
        
        // 触发普通受击特效
        this.hitFlashTime = TimeManager.CONSTANTS.PLAYER_HIT_FLASH_TIME;
        this.hitShakeX = (Math.random() - 0.5) * 12;
        this.hitShakeY = (Math.random() - 0.5) * 12;
        this.hitShieldTime = TimeManager.CONSTANTS.PLAYER_SHIELD_WAVE_TIME;
        this.shieldWave = 0;
        
        // 设置3秒无敌状态（给用户反应时间）
        this.invulnerable = true;
        this.invulnerableTime = TimeManager.CONSTANTS.PLAYER_INVULNERABLE_TIME;
        
        return true; // 返回true表示受到伤害
    }
    
    // 获取碰撞盒的实际坐标和尺寸
    getCollisionBox() {
        return {
            x: this.x + this.collisionBox.offsetX,
            y: this.y + this.collisionBox.offsetY,
            width: this.collisionBox.width,
            height: this.collisionBox.height
        };
    }
    
    render(ctx) {
        ctx.save();
        
        // 应用震动偏移
        const renderX = this.x + this.hitShakeX;
        const renderY = this.y + this.hitShakeY;
        
        // 绘制受击护盾波纹效果
        if (this.hitShieldTime > 0) {
            this.renderHitShield(ctx, renderX, renderY);
        }
        
        // 绘制保护罩效果（蓝色能量罩）
        if (this.shieldActive) {
            this.renderShieldEffect(ctx, renderX, renderY);
        }
        
        // 绘制多发装置效果（绿色能量波）
        if (this.multishotActive) {
            this.renderMultishotEffect(ctx, renderX, renderY);
        }
        
        // 无敌状态闪烁虚化效果（更明显）
        if (this.invulnerable) {
            // 闪烁频率更高，虚化更明显（基于时间而不是帧数）
            const flashCycle = Math.floor((Date.now() / 133)) % 2; // 133ms一个周期
            if (flashCycle === 0) {
                ctx.globalAlpha = 0.3; // 更透明
            } else {
                ctx.globalAlpha = 0.7; // 半透明
            }
        }
        
        // 受击闪烁效果（白光闪烁）
        if (this.hitFlashTime > 0 && Math.floor((Date.now() / 67)) % 2 === 0) { // 67ms一个周期
            ctx.fillStyle = '#ffffff';
            ctx.shadowBlur = 15;
            ctx.shadowColor = '#ffffff';
            ctx.fillRect(renderX, renderY, this.width, this.height);
            ctx.shadowBlur = 0;
        } else {
            // 绘制正常飞机
            this.renderNormal(ctx, renderX, renderY);
        }
        
        // 碰撞盒调试显示（可选）
        if (window.DEBUG_COLLISION_BOX) {
            this.renderCollisionBoxDebug(ctx, renderX, renderY);
        }
        
        ctx.restore();
    }
    
    renderHitShield(ctx, x, y) {
        // 受击护盾波纹效果
        for (let i = 0; i < 3; i++) {
            const waveRadius = 25 + (this.shieldWave * 2) + (i * 8);
            const alpha = (this.hitShieldTime / TimeManager.CONSTANTS.PLAYER_SHIELD_WAVE_TIME) * (1 - i * 0.3) * 0.6;
            
            const gradient = ctx.createRadialGradient(
                x + this.width/2, y + this.height/2, waveRadius * 0.8,
                x + this.width/2, y + this.height/2, waveRadius
            );
            
            gradient.addColorStop(0, `rgba(0, 150, 255, 0)`);
            gradient.addColorStop(0.8, `rgba(0, 150, 255, ${alpha})`);
            gradient.addColorStop(1, `rgba(0, 150, 255, 0)`);
            
            ctx.fillStyle = gradient;
            ctx.beginPath();
            ctx.arc(x + this.width/2, y + this.height/2, waveRadius, 0, Math.PI * 2);
            ctx.fill();
        }
    }
    
    renderNormal(ctx, x, y) {
        ctx.save();
        
        // 应用3D倾斜变换
        const centerX = x + this.width / 2;
        const centerY = y + this.height / 2;
        
        ctx.translate(centerX, centerY);
        ctx.rotate(this.tiltAngle);
        ctx.translate(-centerX, -centerY);
        
        // 绘制炫酷飞机主体
        this.renderAdvancedAircraft(ctx, x, y);
        
        ctx.restore();
    }
    
    renderAdvancedAircraft(ctx, x, y) {
        // 主体阴影效果
        ctx.shadowBlur = 8;
        ctx.shadowColor = '#00ff88';
        
        // 机身主体（流线型设计）
        this.renderFuselage(ctx, x, y);
        
        // 机翼系统
        this.renderWings(ctx, x, y);
        
        // 驾驶舱
        this.renderCockpit(ctx, x, y);
        
        // 推进器
        this.renderThrusters(ctx, x, y);
        
        // 装饰条纹
        this.renderDecorativeStripes(ctx, x, y);
        
        ctx.shadowBlur = 0;
        
        // 引擎光效（增强版）
        this.renderEngines(ctx, x, y);
    }
    
    renderFuselage(ctx, x, y) {
        // 主机身（渐变效果）
        const fuselageGradient = ctx.createLinearGradient(x, y, x + this.width, y);
        fuselageGradient.addColorStop(0, '#004d29');
        fuselageGradient.addColorStop(0.3, '#00ff41');
        fuselageGradient.addColorStop(0.7, '#00ff41');
        fuselageGradient.addColorStop(1, '#004d29');
        
        ctx.fillStyle = fuselageGradient;
        
        // 流线型机身
        ctx.beginPath();
        ctx.moveTo(x + 20, y);
        ctx.quadraticCurveTo(x + 15, y + 5, x + 12, y + 15);
        ctx.lineTo(x + 5, y + 25);
        ctx.lineTo(x + 35, y + 25);
        ctx.quadraticCurveTo(x + 28, y + 5, x + 20, y);
        ctx.fill();
        
        // 机身下部
        ctx.fillStyle = '#00cc33';
        ctx.fillRect(x + 8, y + 25, 24, 8);
        
        // 机身尾部
        const tailGradient = ctx.createLinearGradient(x, y + 30, x + this.width, y + 30);
        tailGradient.addColorStop(0, '#002d1a');
        tailGradient.addColorStop(0.5, '#00ff41');
        tailGradient.addColorStop(1, '#002d1a');
        
        ctx.fillStyle = tailGradient;
        ctx.fillRect(x + 12, y + 33, 16, 7);
    }
    
    renderWings(ctx, x, y) {
        // 主翼（带金属光泽）
        const wingGradient = ctx.createLinearGradient(x, y + 20, x + this.width, y + 20);
        wingGradient.addColorStop(0, '#66ff66');
        wingGradient.addColorStop(0.5, '#ffffff');
        wingGradient.addColorStop(1, '#66ff66');
        
        ctx.fillStyle = wingGradient;
        
        // 左翼
        ctx.beginPath();
        ctx.moveTo(x, y + 22);
        ctx.lineTo(x + 12, y + 20);
        ctx.lineTo(x + 12, y + 28);
        ctx.lineTo(x + 2, y + 30);
        ctx.fill();
        
        // 右翼
        ctx.beginPath();
        ctx.moveTo(x + 40, y + 22);
        ctx.lineTo(x + 28, y + 20);
        ctx.lineTo(x + 28, y + 28);
        ctx.lineTo(x + 38, y + 30);
        ctx.fill();
        
        // 翼尖灯光
        ctx.fillStyle = '#ffffff';
        ctx.fillRect(x, y + 24, 3, 2);
        ctx.fillRect(x + 37, y + 24, 3, 2);
        
        // 翼尖能量效果
        const pulse = 0.7 + Math.sin(this.enginePulse * 2) * 0.3;
        ctx.fillStyle = `rgba(0, 255, 255, ${pulse})`;
        ctx.fillRect(x - 1, y + 23, 2, 4);
        ctx.fillRect(x + 39, y + 23, 2, 4);
    }
    
    renderCockpit(ctx, x, y) {
        // 驾驶舱玻璃（带反光效果）
        const cockpitGradient = ctx.createRadialGradient(
            x + 20, y + 8, 0,
            x + 20, y + 8, 8
        );
        cockpitGradient.addColorStop(0, '#ccffff');
        cockpitGradient.addColorStop(0.6, '#88ddff');
        cockpitGradient.addColorStop(1, '#004466');
        
        ctx.fillStyle = cockpitGradient;
        ctx.beginPath();
        ctx.ellipse(x + 20, y + 8, 6, 8, 0, 0, Math.PI * 2);
        ctx.fill();
        
        // 驾驶舱边框
        ctx.strokeStyle = '#00ff88';
        ctx.lineWidth = 1;
        ctx.beginPath();
        ctx.ellipse(x + 20, y + 8, 6, 8, 0, 0, Math.PI * 2);
        ctx.stroke();
        
        // 驾驶舱内部细节
        ctx.fillStyle = '#ffaa00';
        ctx.fillRect(x + 18, y + 10, 4, 2);
    }
    
    renderThrusters(ctx, x, y) {
        // 推进器外壳
        const thrusterGradient = ctx.createLinearGradient(x, y + 35, x + this.width, y + 35);
        thrusterGradient.addColorStop(0, '#333333');
        thrusterGradient.addColorStop(0.5, '#666666');
        thrusterGradient.addColorStop(1, '#333333');
        
        ctx.fillStyle = thrusterGradient;
        ctx.fillRect(x + 8, y + 35, 10, 5);
        ctx.fillRect(x + 22, y + 35, 10, 5);
        
        // 推进器内部发光
        ctx.fillStyle = '#00ffff';
        ctx.fillRect(x + 10, y + 36, 6, 3);
        ctx.fillRect(x + 24, y + 36, 6, 3);
    }
    
    renderDecorativeStripes(ctx, x, y) {
        // 装饰条纹
        const pulse = 0.8 + Math.sin(this.enginePulse * 1.5) * 0.2;
        ctx.strokeStyle = `rgba(255, 255, 255, ${pulse})`;
        ctx.lineWidth = 1;
        
        // 机身条纹
        ctx.beginPath();
        ctx.moveTo(x + 16, y + 5);
        ctx.lineTo(x + 16, y + 30);
        ctx.stroke();
        
        ctx.beginPath();
        ctx.moveTo(x + 24, y + 5);
        ctx.lineTo(x + 24, y + 30);
        ctx.stroke();
        
        // 能量指示器
        ctx.fillStyle = `rgba(0, 255, 255, ${pulse})`;
        for (let i = 0; i < 3; i++) {
            ctx.fillRect(x + 18 + i * 2, y + 18, 1, 3);
        }
    }
    
    renderEngines(ctx, x, y) {
        // 动态引擎光效
        const pulse = 0.7 + Math.sin(this.enginePulse) * 0.3;
        const flameLength = 8 + Math.sin(this.enginePulse * 1.5) * 3;
        
        // 左引擎
        const leftGradient = ctx.createLinearGradient(x + 10, y + 35, x + 10, y + 35 + flameLength);
        leftGradient.addColorStop(0, `rgba(255, 255, 255, ${pulse})`);
        leftGradient.addColorStop(0.3, `rgba(255, 150, 0, ${pulse * 0.8})`);
        leftGradient.addColorStop(0.7, `rgba(255, 68, 68, ${pulse * 0.6})`);
        leftGradient.addColorStop(1, 'rgba(255, 0, 0, 0)');
        
        ctx.fillStyle = leftGradient;
        ctx.fillRect(x + 8, y + 35, 12, flameLength);
        
        // 右引擎
        const rightGradient = ctx.createLinearGradient(x + 22, y + 35, x + 22, y + 35 + flameLength);
        rightGradient.addColorStop(0, `rgba(255, 255, 255, ${pulse})`);
        rightGradient.addColorStop(0.3, `rgba(255, 150, 0, ${pulse * 0.8})`);
        rightGradient.addColorStop(0.7, `rgba(255, 68, 68, ${pulse * 0.6})`);
        rightGradient.addColorStop(1, 'rgba(255, 0, 0, 0)');
        
        ctx.fillStyle = rightGradient;
        ctx.fillRect(x + 20, y + 35, 12, flameLength);
        
        // 引擎核心
        ctx.fillStyle = '#ffffff';
        ctx.fillRect(x + 10, y + 35, 8, 3);
        ctx.fillRect(x + 22, y + 35, 8, 3);
    }
    
    // 保护罩效果渲染
    renderShieldEffect(ctx, x, y) {
        // 蓝色能量罩（使用独立相位变量）
        const shieldPulse = 0.6 + Math.sin(this.shieldPhase * 2) * 0.4;
        const shieldRadius = 30 + Math.sin(this.shieldPhase * 1.5) * 3;
        
        for (let i = 0; i < 2; i++) {
            const radius = shieldRadius + i * 8;
            const alpha = shieldPulse * (1 - i * 0.3) * 0.4;
            
            const gradient = ctx.createRadialGradient(
                x + this.width/2, y + this.height/2, radius * 0.7,
                x + this.width/2, y + this.height/2, radius
            );
            
            gradient.addColorStop(0, `rgba(68, 68, 255, 0)`);
            gradient.addColorStop(0.8, `rgba(68, 68, 255, ${alpha})`);
            gradient.addColorStop(1, `rgba(68, 68, 255, 0)`);
            
            ctx.fillStyle = gradient;
            ctx.beginPath();
            ctx.arc(x + this.width/2, y + this.height/2, radius, 0, Math.PI * 2);
            ctx.fill();
        }
        
        // 保护罩能量环
        ctx.strokeStyle = `rgba(68, 68, 255, ${shieldPulse * 0.8})`;
        ctx.lineWidth = 2;
        ctx.beginPath();
        ctx.arc(x + this.width/2, y + this.height/2, shieldRadius, 0, Math.PI * 2);
        ctx.stroke();
    }
    
    // 多发装置效果渲染
    renderMultishotEffect(ctx, x, y) {
        // 绿色能量波
        const multishotPulse = 0.7 + Math.sin(this.enginePulse * 2.5) * 0.3;
        
        // 机翼能量效果
        ctx.shadowBlur = 8;
        ctx.shadowColor = '#44ff44';
        
        // 左机翼能量
        ctx.fillStyle = `rgba(68, 255, 68, ${multishotPulse * 0.6})`;
        ctx.fillRect(x, y + 20, 5, 15);
        
        // 右机翼能量
        ctx.fillRect(x + 35, y + 20, 5, 15);
        
        // 能量脉冲线
        for (let i = 0; i < 3; i++) {
            const lineY = y + 10 + i * 8;
            const alpha = multishotPulse * (1 - i * 0.2);
            ctx.strokeStyle = `rgba(68, 255, 68, ${alpha})`;
            ctx.lineWidth = 1;
            ctx.beginPath();
            ctx.moveTo(x + 5, lineY);
            ctx.lineTo(x + 35, lineY);
            ctx.stroke();
        }
        
        ctx.shadowBlur = 0;
    }
    
    // 碰撞盒调试可视化
    renderCollisionBoxDebug(ctx, renderX, renderY) {
        const collisionBox = this.getCollisionBox();
        
        ctx.save();
        
        // 绘制碰撞盒边框（红色虚线）
        ctx.strokeStyle = '#ff0000';
        ctx.lineWidth = 2;
        ctx.setLineDash([4, 4]);
        ctx.strokeRect(collisionBox.x, collisionBox.y, collisionBox.width, collisionBox.height);
        
        // 绘制原始尺寸边框（黄色细线）
        ctx.strokeStyle = '#ffff00';
        ctx.lineWidth = 1;
        ctx.setLineDash([2, 2]);
        ctx.strokeRect(renderX, renderY, this.width, this.height);
        
        // 重置线条样式
        ctx.setLineDash([]);
        
        ctx.restore();
    }
}